# uncompyle6 version 3.2.3
# Python bytecode 3.6 (3379)
# Decompiled from: Python 3.6.8 |Anaconda custom (64-bit)| (default, Feb 21 2019, 18:30:04) [MSC v.1916 64 bit (AMD64)]
# Embedded file name: site-packages\gevent\thread.py
"""
Implementation of the standard :mod:`thread` module that spawns greenlets.

.. note::

    This module is a helper for :mod:`gevent.monkey` and is not
    intended to be used directly. For spawning greenlets in your
    applications, prefer higher level constructs like
    :class:`gevent.Greenlet` class or :func:`gevent.spawn`.
"""
from __future__ import absolute_import
import sys

__implements__ = [
    "allocate_lock",
    "get_ident",
    "exit",
    "LockType",
    "stack_size",
    "start_new_thread",
    "_local",
]
__imports__ = ["error"]
if sys.version_info[0] <= 2:
    import thread as __thread__
else:
    import _thread as __thread__

    __target__ = "_thread"
    __imports__ += [
        "RLock",
        "TIMEOUT_MAX",
        "allocate",
        "exit_thread",
        "interrupt_main",
        "start_new",
    ]
error = __thread__.error
from gevent._compat import PY3
from gevent._compat import PYPY
from gevent._util import copy_globals
from gevent.hub import getcurrent, GreenletExit
from gevent.greenlet import Greenlet
from gevent.lock import BoundedSemaphore
from gevent.local import local as _local


def get_ident(gr=None):
    if gr is None:
        gr = getcurrent()
    return id(gr)


def start_new_thread(function, args=(), kwargs=None):
    if kwargs is not None:
        greenlet = Greenlet.spawn(function, *args, **kwargs)
    else:
        greenlet = Greenlet.spawn(function, *args)
    return get_ident(greenlet)


class LockType(BoundedSemaphore):
    _OVER_RELEASE_ERROR = __thread__.error
    if PYPY:
        if PY3:
            _OVER_RELEASE_ERROR = RuntimeError
    if PY3:
        _TIMEOUT_MAX = __thread__.TIMEOUT_MAX

        def acquire(self, blocking=True, timeout=-1):
            if timeout == -1:
                timeout = None
            if not blocking:
                if timeout is not None:
                    raise ValueError("can't specify a timeout for a non-blocking call")
            if timeout is not None:
                if timeout < 0:
                    raise ValueError("timeout value must be strictly positive")
                if timeout > self._TIMEOUT_MAX:
                    raise OverflowError("timeout value is too large")
            return BoundedSemaphore.acquire(self, blocking, timeout)


allocate_lock = LockType


def exit():
    raise GreenletExit


if hasattr(__thread__, "stack_size"):
    _original_stack_size = __thread__.stack_size

    def stack_size(size=None):
        if size is None:
            return _original_stack_size()
        if size > _original_stack_size():
            return _original_stack_size(size)


else:
    __implements__.remove("stack_size")
__imports__ = copy_globals(
    __thread__, globals(), only_names=__imports__, ignore_missing_names=True
)
__all__ = __implements__ + __imports__
__all__.remove("_local")
